home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / wave.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  18KB  |  552 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """Stuff to parse WAVE files.
  5.  
  6. Usage.
  7.  
  8. Reading WAVE files:
  9.       f = wave.open(file, 'r')
  10. where file is either the name of a file or an open file pointer.
  11. The open file pointer must have methods read(), seek(), and close().
  12. When the setpos() and rewind() methods are not used, the seek()
  13. method is not  necessary.
  14.  
  15. This returns an instance of a class with the following public methods:
  16.       getnchannels()  -- returns number of audio channels (1 for
  17.                          mono, 2 for stereo)
  18.       getsampwidth()  -- returns sample width in bytes
  19.       getframerate()  -- returns sampling frequency
  20.       getnframes()    -- returns number of audio frames
  21.       getcomptype()   -- returns compression type ('NONE' for linear samples)
  22.       getcompname()   -- returns human-readable version of
  23.                          compression type ('not compressed' linear samples)
  24.       getparams()     -- returns a tuple consisting of all of the
  25.                          above in the above order
  26.       getmarkers()    -- returns None (for compatibility with the
  27.                          aifc module)
  28.       getmark(id)     -- raises an error since the mark does not
  29.                          exist (for compatibility with the aifc module)
  30.       readframes(n)   -- returns at most n frames of audio
  31.       rewind()        -- rewind to the beginning of the audio stream
  32.       setpos(pos)     -- seek to the specified position
  33.       tell()          -- return the current position
  34.       close()         -- close the instance (make it unusable)
  35. The position returned by tell() and the position given to setpos()
  36. are compatible and have nothing to do with the actual position in the
  37. file.
  38. The close() method is called automatically when the class instance
  39. is destroyed.
  40.  
  41. Writing WAVE files:
  42.       f = wave.open(file, 'w')
  43. where file is either the name of a file or an open file pointer.
  44. The open file pointer must have methods write(), tell(), seek(), and
  45. close().
  46.  
  47. This returns an instance of a class with the following public methods:
  48.       setnchannels(n) -- set the number of channels
  49.       setsampwidth(n) -- set the sample width
  50.       setframerate(n) -- set the frame rate
  51.       setnframes(n)   -- set the number of frames
  52.       setcomptype(type, name)
  53.                       -- set the compression type and the
  54.                          human-readable compression type
  55.       setparams(tuple)
  56.                       -- set all parameters at once
  57.       tell()          -- return current position in output file
  58.       writeframesraw(data)
  59.                       -- write audio frames without pathing up the
  60.                          file header
  61.       writeframes(data)
  62.                       -- write audio frames and patch up the file header
  63.       close()         -- patch up the file header and close the
  64.                          output file
  65. You should set the parameters before the first writeframesraw or
  66. writeframes.  The total number of frames does not need to be set,
  67. but when it is set to the correct value, the header does not have to
  68. be patched up.
  69. It is best to first set all parameters, perhaps possibly the
  70. compression type, and then write audio frames using writeframesraw.
  71. When all frames have been written, either call writeframes('') or
  72. close() to patch up the sizes in the header.
  73. The close() method is called automatically when the class instance
  74. is destroyed.
  75. """
  76. import __builtin__
  77. __all__ = [
  78.     'open',
  79.     'openfp',
  80.     'Error']
  81.  
  82. class Error(Exception):
  83.     pass
  84.  
  85. WAVE_FORMAT_PCM = 1
  86. _array_fmts = (None, 'b', 'h', None, 'l')
  87. import struct
  88. if struct.pack('h', 1) == '\x00\x01':
  89.     big_endian = 1
  90. else:
  91.     big_endian = 0
  92. from chunk import Chunk
  93.  
  94. class Wave_read:
  95.     """Variables used in this class:
  96.  
  97.     These variables are available to the user though appropriate
  98.     methods of this class:
  99.     _file -- the open file with methods read(), close(), and seek()
  100.               set through the __init__() method
  101.     _nchannels -- the number of audio channels
  102.               available through the getnchannels() method
  103.     _nframes -- the number of audio frames
  104.               available through the getnframes() method
  105.     _sampwidth -- the number of bytes per audio sample
  106.               available through the getsampwidth() method
  107.     _framerate -- the sampling frequency
  108.               available through the getframerate() method
  109.     _comptype -- the AIFF-C compression type ('NONE' if AIFF)
  110.               available through the getcomptype() method
  111.     _compname -- the human-readable AIFF-C compression type
  112.               available through the getcomptype() method
  113.     _soundpos -- the position in the audio stream
  114.               available through the tell() method, set through the
  115.               setpos() method
  116.  
  117.     These variables are used internally only:
  118.     _fmt_chunk_read -- 1 iff the FMT chunk has been read
  119.     _data_seek_needed -- 1 iff positioned correctly in audio
  120.               file for readframes()
  121.     _data_chunk -- instantiation of a chunk class for the DATA chunk
  122.     _framesize -- size of one frame in the file
  123.     """
  124.     
  125.     def initfp(self, file):
  126.         self._convert = None
  127.         self._soundpos = 0
  128.         self._file = Chunk(file, bigendian = 0)
  129.         if self._file.getname() != 'RIFF':
  130.             raise Error, 'file does not start with RIFF id'
  131.         
  132.         if self._file.read(4) != 'WAVE':
  133.             raise Error, 'not a WAVE file'
  134.         
  135.         self._fmt_chunk_read = 0
  136.         self._data_chunk = None
  137.         while None:
  138.             self._data_seek_needed = 1
  139.             
  140.             try:
  141.                 chunk = Chunk(self._file, bigendian = 0)
  142.             except EOFError:
  143.                 break
  144.  
  145.             chunkname = chunk.getname()
  146.             if chunkname == 'fmt ':
  147.                 self._read_fmt_chunk(chunk)
  148.                 self._fmt_chunk_read = 1
  149.             elif chunkname == 'data':
  150.                 if not self._fmt_chunk_read:
  151.                     raise Error, 'data chunk before fmt chunk'
  152.                 
  153.                 self._data_chunk = chunk
  154.                 self._nframes = chunk.chunksize // self._framesize
  155.                 self._data_seek_needed = 0
  156.                 break
  157.             
  158.         if not (self._fmt_chunk_read) or not (self._data_chunk):
  159.             raise Error, 'fmt chunk and/or data chunk missing'
  160.         
  161.  
  162.     
  163.     def __init__(self, f):
  164.         self._i_opened_the_file = None
  165.         if isinstance(f, basestring):
  166.             f = __builtin__.open(f, 'rb')
  167.             self._i_opened_the_file = f
  168.         
  169.         self.initfp(f)
  170.  
  171.     
  172.     def __del__(self):
  173.         self.close()
  174.  
  175.     
  176.     def getfp(self):
  177.         return self._file
  178.  
  179.     
  180.     def rewind(self):
  181.         self._data_seek_needed = 1
  182.         self._soundpos = 0
  183.  
  184.     
  185.     def close(self):
  186.         if self._i_opened_the_file:
  187.             self._i_opened_the_file.close()
  188.             self._i_opened_the_file = None
  189.         
  190.         self._file = None
  191.  
  192.     
  193.     def tell(self):
  194.         return self._soundpos
  195.  
  196.     
  197.     def getnchannels(self):
  198.         return self._nchannels
  199.  
  200.     
  201.     def getnframes(self):
  202.         return self._nframes
  203.  
  204.     
  205.     def getsampwidth(self):
  206.         return self._sampwidth
  207.  
  208.     
  209.     def getframerate(self):
  210.         return self._framerate
  211.  
  212.     
  213.     def getcomptype(self):
  214.         return self._comptype
  215.  
  216.     
  217.     def getcompname(self):
  218.         return self._compname
  219.  
  220.     
  221.     def getparams(self):
  222.         return (self.getnchannels(), self.getsampwidth(), self.getframerate(), self.getnframes(), self.getcomptype(), self.getcompname())
  223.  
  224.     
  225.     def getmarkers(self):
  226.         pass
  227.  
  228.     
  229.     def getmark(self, id):
  230.         raise Error, 'no marks'
  231.  
  232.     
  233.     def setpos(self, pos):
  234.         if pos < 0 or pos > self._nframes:
  235.             raise Error, 'position not in range'
  236.         
  237.         self._soundpos = pos
  238.         self._data_seek_needed = 1
  239.  
  240.     
  241.     def readframes(self, nframes):
  242.         if self._data_seek_needed:
  243.             self._data_chunk.seek(0, 0)
  244.             pos = self._soundpos * self._framesize
  245.             if pos:
  246.                 self._data_chunk.seek(pos, 0)
  247.             
  248.             self._data_seek_needed = 0
  249.         
  250.         if nframes == 0:
  251.             return ''
  252.         
  253.         if self._sampwidth > 1 and big_endian:
  254.             import array as array
  255.             chunk = self._data_chunk
  256.             data = array.array(_array_fmts[self._sampwidth])
  257.             nitems = nframes * self._nchannels
  258.             if nitems * self._sampwidth > chunk.chunksize - chunk.size_read:
  259.                 nitems = (chunk.chunksize - chunk.size_read) / self._sampwidth
  260.             
  261.             data.fromfile(chunk.file.file, nitems)
  262.             chunk.size_read = chunk.size_read + nitems * self._sampwidth
  263.             chunk = chunk.file
  264.             chunk.size_read = chunk.size_read + nitems * self._sampwidth
  265.             data.byteswap()
  266.             data = data.tostring()
  267.         else:
  268.             data = self._data_chunk.read(nframes * self._framesize)
  269.         if self._convert and data:
  270.             data = self._convert(data)
  271.         
  272.         self._soundpos = self._soundpos + len(data) // self._nchannels * self._sampwidth
  273.         return data
  274.  
  275.     
  276.     def _read_fmt_chunk(self, chunk):
  277.         (wFormatTag, self._nchannels, self._framerate, dwAvgBytesPerSec, wBlockAlign) = struct.unpack('<hhllh', chunk.read(14))
  278.         if wFormatTag == WAVE_FORMAT_PCM:
  279.             sampwidth = struct.unpack('<h', chunk.read(2))[0]
  280.             self._sampwidth = (sampwidth + 7) // 8
  281.         else:
  282.             raise Error, 'unknown format: %r' % (wFormatTag,)
  283.         self._framesize = self._nchannels * self._sampwidth
  284.         self._comptype = 'NONE'
  285.         self._compname = 'not compressed'
  286.  
  287.  
  288.  
  289. class Wave_write:
  290.     """Variables used in this class:
  291.  
  292.     These variables are user settable through appropriate methods
  293.     of this class:
  294.     _file -- the open file with methods write(), close(), tell(), seek()
  295.               set through the __init__() method
  296.     _comptype -- the AIFF-C compression type ('NONE' in AIFF)
  297.               set through the setcomptype() or setparams() method
  298.     _compname -- the human-readable AIFF-C compression type
  299.               set through the setcomptype() or setparams() method
  300.     _nchannels -- the number of audio channels
  301.               set through the setnchannels() or setparams() method
  302.     _sampwidth -- the number of bytes per audio sample
  303.               set through the setsampwidth() or setparams() method
  304.     _framerate -- the sampling frequency
  305.               set through the setframerate() or setparams() method
  306.     _nframes -- the number of audio frames written to the header
  307.               set through the setnframes() or setparams() method
  308.  
  309.     These variables are used internally only:
  310.     _datalength -- the size of the audio samples written to the header
  311.     _nframeswritten -- the number of frames actually written
  312.     _datawritten -- the size of the audio samples actually written
  313.     """
  314.     
  315.     def __init__(self, f):
  316.         self._i_opened_the_file = None
  317.         if isinstance(f, basestring):
  318.             f = __builtin__.open(f, 'wb')
  319.             self._i_opened_the_file = f
  320.         
  321.         self.initfp(f)
  322.  
  323.     
  324.     def initfp(self, file):
  325.         self._file = file
  326.         self._convert = None
  327.         self._nchannels = 0
  328.         self._sampwidth = 0
  329.         self._framerate = 0
  330.         self._nframes = 0
  331.         self._nframeswritten = 0
  332.         self._datawritten = 0
  333.         self._datalength = 0
  334.  
  335.     
  336.     def __del__(self):
  337.         self.close()
  338.  
  339.     
  340.     def setnchannels(self, nchannels):
  341.         if self._datawritten:
  342.             raise Error, 'cannot change parameters after starting to write'
  343.         
  344.         if nchannels < 1:
  345.             raise Error, 'bad # of channels'
  346.         
  347.         self._nchannels = nchannels
  348.  
  349.     
  350.     def getnchannels(self):
  351.         if not self._nchannels:
  352.             raise Error, 'number of channels not set'
  353.         
  354.         return self._nchannels
  355.  
  356.     
  357.     def setsampwidth(self, sampwidth):
  358.         if self._datawritten:
  359.             raise Error, 'cannot change parameters after starting to write'
  360.         
  361.         if sampwidth < 1 or sampwidth > 4:
  362.             raise Error, 'bad sample width'
  363.         
  364.         self._sampwidth = sampwidth
  365.  
  366.     
  367.     def getsampwidth(self):
  368.         if not self._sampwidth:
  369.             raise Error, 'sample width not set'
  370.         
  371.         return self._sampwidth
  372.  
  373.     
  374.     def setframerate(self, framerate):
  375.         if self._datawritten:
  376.             raise Error, 'cannot change parameters after starting to write'
  377.         
  378.         if framerate <= 0:
  379.             raise Error, 'bad frame rate'
  380.         
  381.         self._framerate = framerate
  382.  
  383.     
  384.     def getframerate(self):
  385.         if not self._framerate:
  386.             raise Error, 'frame rate not set'
  387.         
  388.         return self._framerate
  389.  
  390.     
  391.     def setnframes(self, nframes):
  392.         if self._datawritten:
  393.             raise Error, 'cannot change parameters after starting to write'
  394.         
  395.         self._nframes = nframes
  396.  
  397.     
  398.     def getnframes(self):
  399.         return self._nframeswritten
  400.  
  401.     
  402.     def setcomptype(self, comptype, compname):
  403.         if self._datawritten:
  404.             raise Error, 'cannot change parameters after starting to write'
  405.         
  406.         if comptype not in ('NONE',):
  407.             raise Error, 'unsupported compression type'
  408.         
  409.         self._comptype = comptype
  410.         self._compname = compname
  411.  
  412.     
  413.     def getcomptype(self):
  414.         return self._comptype
  415.  
  416.     
  417.     def getcompname(self):
  418.         return self._compname
  419.  
  420.     
  421.     def setparams(self, .2):
  422.         (nchannels, sampwidth, framerate, nframes, comptype, compname) = .2
  423.         if self._datawritten:
  424.             raise Error, 'cannot change parameters after starting to write'
  425.         
  426.         self.setnchannels(nchannels)
  427.         self.setsampwidth(sampwidth)
  428.         self.setframerate(framerate)
  429.         self.setnframes(nframes)
  430.         self.setcomptype(comptype, compname)
  431.  
  432.     
  433.     def getparams(self):
  434.         if not (self._nchannels) and not (self._sampwidth) or not (self._framerate):
  435.             raise Error, 'not all parameters set'
  436.         
  437.         return (self._nchannels, self._sampwidth, self._framerate, self._nframes, self._comptype, self._compname)
  438.  
  439.     
  440.     def setmark(self, id, pos, name):
  441.         raise Error, 'setmark() not supported'
  442.  
  443.     
  444.     def getmark(self, id):
  445.         raise Error, 'no marks'
  446.  
  447.     
  448.     def getmarkers(self):
  449.         pass
  450.  
  451.     
  452.     def tell(self):
  453.         return self._nframeswritten
  454.  
  455.     
  456.     def writeframesraw(self, data):
  457.         self._ensure_header_written(len(data))
  458.         nframes = len(data) // self._sampwidth * self._nchannels
  459.         if self._convert:
  460.             data = self._convert(data)
  461.         
  462.         if self._sampwidth > 1 and big_endian:
  463.             import array
  464.             data = array.array(_array_fmts[self._sampwidth], data)
  465.             data.byteswap()
  466.             data.tofile(self._file)
  467.             self._datawritten = self._datawritten + len(data) * self._sampwidth
  468.         else:
  469.             self._file.write(data)
  470.             self._datawritten = self._datawritten + len(data)
  471.         self._nframeswritten = self._nframeswritten + nframes
  472.  
  473.     
  474.     def writeframes(self, data):
  475.         self.writeframesraw(data)
  476.         if self._datalength != self._datawritten:
  477.             self._patchheader()
  478.         
  479.  
  480.     
  481.     def close(self):
  482.         if self._file:
  483.             self._ensure_header_written(0)
  484.             if self._datalength != self._datawritten:
  485.                 self._patchheader()
  486.             
  487.             self._file.flush()
  488.             self._file = None
  489.         
  490.         if self._i_opened_the_file:
  491.             self._i_opened_the_file.close()
  492.             self._i_opened_the_file = None
  493.         
  494.  
  495.     
  496.     def _ensure_header_written(self, datasize):
  497.         if not self._datawritten:
  498.             if not self._nchannels:
  499.                 raise Error, '# channels not specified'
  500.             
  501.             if not self._sampwidth:
  502.                 raise Error, 'sample width not specified'
  503.             
  504.             if not self._framerate:
  505.                 raise Error, 'sampling rate not specified'
  506.             
  507.             self._write_header(datasize)
  508.         
  509.  
  510.     
  511.     def _write_header(self, initlength):
  512.         self._file.write('RIFF')
  513.         if not self._nframes:
  514.             self._nframes = initlength / self._nchannels * self._sampwidth
  515.         
  516.         self._datalength = self._nframes * self._nchannels * self._sampwidth
  517.         self._form_length_pos = self._file.tell()
  518.         self._file.write(struct.pack('<l4s4slhhllhh4s', 36 + self._datalength, 'WAVE', 'fmt ', 16, WAVE_FORMAT_PCM, self._nchannels, self._framerate, self._nchannels * self._framerate * self._sampwidth, self._nchannels * self._sampwidth, self._sampwidth * 8, 'data'))
  519.         self._data_length_pos = self._file.tell()
  520.         self._file.write(struct.pack('<l', self._datalength))
  521.  
  522.     
  523.     def _patchheader(self):
  524.         if self._datawritten == self._datalength:
  525.             return None
  526.         
  527.         curpos = self._file.tell()
  528.         self._file.seek(self._form_length_pos, 0)
  529.         self._file.write(struct.pack('<l', 36 + self._datawritten))
  530.         self._file.seek(self._data_length_pos, 0)
  531.         self._file.write(struct.pack('<l', self._datawritten))
  532.         self._file.seek(curpos, 0)
  533.         self._datalength = self._datawritten
  534.  
  535.  
  536.  
  537. def open(f, mode = None):
  538.     if mode is None:
  539.         if hasattr(f, 'mode'):
  540.             mode = f.mode
  541.         else:
  542.             mode = 'rb'
  543.     
  544.     if mode in ('r', 'rb'):
  545.         return Wave_read(f)
  546.     elif mode in ('w', 'wb'):
  547.         return Wave_write(f)
  548.     else:
  549.         raise Error, "mode must be 'r', 'rb', 'w', or 'wb'"
  550.  
  551. openfp = open
  552.